const express = require('express');
const router = express.Router();
const FoodCategory = require('../models/FoodCategory');

// 获取所有食品种类
router.get('/', async (req, res) => {
  try {
    const categories = await FoodCategory.getAllCategories();
    res.json({
      code: 200,
      message: 'success',
      data: categories
    });
  } catch (error) {
    console.error('获取食品种类列表失败:', error.message);
    res.status(500).json({
      code: 500,
      message: '获取食品种类列表失败',
      error: error.message
    });
  }
});

// 获取格式化的种类选项（用于前端下拉选择）
router.get('/options', async (req, res) => {
  try {
    const options = await FoodCategory.getCategoryOptions();
    res.json({
      code: 200,
      message: 'success',
      data: options
    });
  } catch (error) {
    console.error('获取食品种类选项失败:', error.message);
    res.status(500).json({
      code: 500,
      message: '获取食品种类选项失败',
      error: error.message
    });
  }
});

// 获取食品种类统计信息
router.get('/stats', async (req, res) => {
  try {
    const stats = await FoodCategory.getCategoryStats();
    res.json({
      code: 200,
      message: 'success',
      data: stats
    });
  } catch (error) {
    console.error('获取食品种类统计失败:', error.message);
    res.status(500).json({
      code: 500,
      message: '获取食品种类统计失败',
      error: error.message
    });
  }
});

// 根据ID获取食品种类详情
router.get('/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const category = await FoodCategory.getCategoryById(id);
    
    if (!category) {
      return res.status(404).json({
        code: 404,
        message: '未找到指定的食品种类',
        data: null
      });
    }

    res.json({
      code: 200,
      message: 'success',
      data: category
    });
  } catch (error) {
    console.error('获取食品种类详情失败:', error.message);
    res.status(500).json({
      code: 500,
      message: '获取食品种类详情失败',
      error: error.message
    });
  }
});

// 根据type_value获取食品种类详情
router.get('/value/:typeValue', async (req, res) => {
  try {
    const { typeValue } = req.params;
    const category = await FoodCategory.getCategoryByValue(typeValue);
    
    if (!category) {
      return res.status(404).json({
        code: 404,
        message: '未找到指定的食品种类',
        data: null
      });
    }

    res.json({
      code: 200,
      message: 'success',
      data: category
    });
  } catch (error) {
    console.error('根据值获取食品种类失败:', error.message);
    res.status(500).json({
      code: 500,
      message: '根据值获取食品种类失败',
      error: error.message
    });
  }
});

// 创建食品种类
router.post('/', async (req, res) => {
  try {
    const { type_name, type_value } = req.body;
    
    // 验证必填参数
    if (!type_name || !type_value) {
      return res.status(400).json({
        code: 400,
        message: '种类名称和种类值不能为空',
        data: null
      });
    }

    // 检查type_value是否已存在
    const exists = await FoodCategory.checkValueExists(type_value);
    if (exists) {
      return res.status(409).json({
        code: 409,
        message: '该种类值已存在',
        data: null
      });
    }

    const category = await FoodCategory.createCategory({ type_name, type_value });
    res.status(201).json({
      code: 201,
      message: '食品种类创建成功',
      data: category
    });
  } catch (error) {
    console.error('创建食品种类失败:', error.message);
    res.status(500).json({
      code: 500,
      message: '创建食品种类失败',
      error: error.message
    });
  }
});

// 批量创建食品种类
router.post('/batch', async (req, res) => {
  try {
    const { categories } = req.body;
    
    if (!Array.isArray(categories) || categories.length === 0) {
      return res.status(400).json({
        code: 400,
        message: '请提供有效的种类数组',
        data: null
      });
    }

    // 验证每个种类的必填字段
    for (const category of categories) {
      if (!category.type_name || !category.type_value) {
        return res.status(400).json({
          code: 400,
          message: '每个种类的名称和值都不能为空',
          data: null
        });
      }
    }

    const createdCategories = await FoodCategory.batchCreateCategories(categories);
    res.status(201).json({
      code: 201,
      message: '批量创建食品种类成功',
      data: createdCategories
    });
  } catch (error) {
    console.error('批量创建食品种类失败:', error.message);
    res.status(500).json({
      code: 500,
      message: '批量创建食品种类失败',
      error: error.message
    });
  }
});

// 更新食品种类
router.put('/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const { type_name, type_value } = req.body;
    
    // 验证必填参数
    if (!type_name || !type_value) {
      return res.status(400).json({
        code: 400,
        message: '种类名称和种类值不能为空',
        data: null
      });
    }

    // 检查type_value是否已被其他记录使用
    const exists = await FoodCategory.checkValueExists(type_value, id);
    if (exists) {
      return res.status(409).json({
        code: 409,
        message: '该种类值已被其他记录使用',
        data: null
      });
    }

    const updatedCategory = await FoodCategory.updateCategory(id, { type_name, type_value });
    
    if (!updatedCategory) {
      return res.status(404).json({
        code: 404,
        message: '未找到指定的食品种类',
        data: null
      });
    }

    res.json({
      code: 200,
      message: '食品种类更新成功',
      data: updatedCategory
    });
  } catch (error) {
    console.error('更新食品种类失败:', error.message);
    res.status(500).json({
      code: 500,
      message: '更新食品种类失败',
      error: error.message
    });
  }
});

// 删除食品种类（级联删除相关食物模板和食物）
router.delete('/:id', async (req, res) => {
  try {
    const { id } = req.params;
    
    const deleteResult = await FoodCategory.deleteCategory(id);
    
    if (!deleteResult) {
      return res.status(404).json({
        code: 404,
        message: '未找到指定的食品种类',
        data: null
      });
    }

    // 构建详细的删除信息
    const { category, deletedFoods, deletedTemplates } = deleteResult;
    let detailMessage = `已成功删除食品种类 "${category}"`;
    
    if (deletedTemplates > 0) {
      detailMessage += `，同步删除了 ${deletedTemplates} 个相关的食物模板`;
    }
    
    if (deletedFoods > 0) {
      detailMessage += `，同步删除了 ${deletedFoods} 个相关的食物记录`;
    }

    res.json({
      code: 200,
      message: detailMessage,
      data: {
        deletedCategory: category,
        deletedTemplates: deletedTemplates,
        deletedFoods: deletedFoods,
        summary: `级联删除完成：删除 1 个食品种类、${deletedTemplates} 个食物模板、${deletedFoods} 个食物记录`
      }
    });
  } catch (error) {
    console.error('删除食品种类失败:', error.message);
    res.status(500).json({
      code: 500,
      message: '删除食品种类失败',
      error: error.message
    });
  }
});

// 搜索食品种类
router.get('/search/:keyword', async (req, res) => {
  try {
    const { keyword } = req.params;
    
    if (!keyword || keyword.trim() === '') {
      return res.status(400).json({
        code: 400,
        message: '搜索关键词不能为空',
        data: []
      });
    }

    const categories = await FoodCategory.searchCategories(keyword.trim());
    res.json({
      code: 200,
      message: 'success',
      data: categories
    });
  } catch (error) {
    console.error('搜索食品种类失败:', error.message);
    res.status(500).json({
      code: 500,
      message: '搜索食品种类失败',
      error: error.message
    });
  }
});

module.exports = router;
